home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / gnu / gcc_260.zip / gcc_260 / gcc.info-21 (.txt) < prev    next >
GNU Info File  |  1994-07-14  |  45KB  |  782 lines
  1. This is Info file gcc.info, produced by Makeinfo-1.54 from the input
  2. file gcc.texi.
  3.    This file documents the use and the internals of the GNU compiler.
  4.    Published by the Free Software Foundation 675 Massachusetts Avenue
  5. Cambridge, MA 02139 USA
  6.    Copyright (C) 1988, 1989, 1992, 1993 Free Software Foundation, Inc.
  7.    Permission is granted to make and distribute verbatim copies of this
  8. manual provided the copyright notice and this permission notice are
  9. preserved on all copies.
  10.    Permission is granted to copy and distribute modified versions of
  11. this manual under the conditions for verbatim copying, provided also
  12. that the sections entitled "GNU General Public License" and "Protect
  13. Your Freedom--Fight `Look And Feel'" are included exactly as in the
  14. original, and provided that the entire resulting derived work is
  15. distributed under the terms of a permission notice identical to this
  16.    Permission is granted to copy and distribute translations of this
  17. manual into another language, under the above conditions for modified
  18. versions, except that the sections entitled "GNU General Public
  19. License" and "Protect Your Freedom--Fight `Look And Feel'", and this
  20. permission notice, may be included in translations approved by the Free
  21. Software Foundation instead of in the original English.
  22. File: gcc.info,  Node: Condition Code,  Next: Costs,  Prev: Addressing Modes,  Up: Target Macros
  23. Condition Code Status
  24. =====================
  25.    The file `conditions.h' defines a variable `cc_status' to describe
  26. how the condition code was computed (in case the interpretation of the
  27. condition code depends on the instruction that it was set by).  This
  28. variable contains the RTL expressions on which the condition code is
  29. currently based, and several standard flags.
  30.    Sometimes additional machine-specific flags must be defined in the
  31. machine description header file.  It can also add additional
  32. machine-specific information by defining `CC_STATUS_MDEP'.
  33. `CC_STATUS_MDEP'
  34.      C code for a data type which is used for declaring the `mdep'
  35.      component of `cc_status'.  It defaults to `int'.
  36.      This macro is not used on machines that do not use `cc0'.
  37. `CC_STATUS_MDEP_INIT'
  38.      A C expression to initialize the `mdep' field to "empty".  The
  39.      default definition does nothing, since most machines don't use the
  40.      field anyway.  If you want to use the field, you should probably
  41.      define this macro to initialize it.
  42.      This macro is not used on machines that do not use `cc0'.
  43. `NOTICE_UPDATE_CC (EXP, INSN)'
  44.      A C compound statement to set the components of `cc_status'
  45.      appropriately for an insn INSN whose body is EXP.  It is this
  46.      macro's responsibility to recognize insns that set the condition
  47.      code as a byproduct of other activity as well as those that
  48.      explicitly set `(cc0)'.
  49.      This macro is not used on machines that do not use `cc0'.
  50.      If there are insns that do not set the condition code but do alter
  51.      other machine registers, this macro must check to see whether they
  52.      invalidate the expressions that the condition code is recorded as
  53.      reflecting.  For example, on the 68000, insns that store in address
  54.      registers do not set the condition code, which means that usually
  55.      `NOTICE_UPDATE_CC' can leave `cc_status' unaltered for such insns.
  56.      But suppose that the previous insn set the condition code based
  57.      on location `a4@(102)' and the current insn stores a new value in
  58.      `a4'.  Although the condition code is not changed by this, it will
  59.      no longer be true that it reflects the contents of `a4@(102)'.
  60.      Therefore, `NOTICE_UPDATE_CC' must alter `cc_status' in this case
  61.      to say that nothing is known about the condition code value.
  62.      The definition of `NOTICE_UPDATE_CC' must be prepared to deal with
  63.      the results of peephole optimization: insns whose patterns are
  64.      `parallel' RTXs containing various `reg', `mem' or constants which
  65.      are just the operands.  The RTL structure of these insns is not
  66.      sufficient to indicate what the insns actually do.  What
  67.      `NOTICE_UPDATE_CC' should do when it sees one is just to run
  68.      `CC_STATUS_INIT'.
  69.      A possible definition of `NOTICE_UPDATE_CC' is to call a function
  70.      that looks at an attribute (*note Insn Attributes::.) named, for
  71.      example, `cc'.  This avoids having detailed information about
  72.      patterns in two places, the `md' file and in `NOTICE_UPDATE_CC'.
  73. `EXTRA_CC_MODES'
  74.      A list of names to be used for additional modes for condition code
  75.      values in registers (*note Jump Patterns::.).  These names are
  76.      added to `enum machine_mode' and all have class `MODE_CC'.  By
  77.      convention, they should start with `CC' and end with `mode'.
  78.      You should only define this macro if your machine does not use
  79.      `cc0' and only if additional modes are required.
  80. `EXTRA_CC_NAMES'
  81.      A list of C strings giving the names for the modes listed in
  82.      `EXTRA_CC_MODES'.  For example, the Sparc defines this macro and
  83.      `EXTRA_CC_MODES' as
  84.           #define EXTRA_CC_MODES CC_NOOVmode, CCFPmode, CCFPEmode
  85.           #define EXTRA_CC_NAMES "CC_NOOV", "CCFP", "CCFPE"
  86.      This macro is not required if `EXTRA_CC_MODES' is not defined.
  87. `SELECT_CC_MODE (OP, X, Y)'
  88.      Returns a mode from class `MODE_CC' to be used when comparison
  89.      operation code OP is applied to rtx X and Y.  For example, on the
  90.      Sparc, `SELECT_CC_MODE' is defined as (see *note Jump Patterns::.
  91.      for a description of the reason for this definition)
  92.           #define SELECT_CC_MODE(OP,X,Y) \
  93.             (GET_MODE_CLASS (GET_MODE (X)) == MODE_FLOAT          \
  94.              ? ((OP == EQ || OP == NE) ? CCFPmode : CCFPEmode)    \
  95.              : ((GET_CODE (X) == PLUS || GET_CODE (X) == MINUS    \
  96.                  || GET_CODE (X) == NEG) \
  97.                 ? CC_NOOVmode : CCmode))
  98.      You need not define this macro if `EXTRA_CC_MODES' is not defined.
  99. `CANONICALIZE_COMPARISON (CODE, OP0, OP1)'
  100.      One some machines not all possible comparisons are defined, but
  101.      you can convert an invalid comparison into a valid one.  For
  102.      example, the Alpha does not have a `GT' comparison, but you can
  103.      use an `LT' comparison instead and swap the order of the operands.
  104.      On such machines, define this macro to be a C statement to do any
  105.      required conversions.  CODE is the initial comparison code and OP0
  106.      and OP1 are the left and right operands of the comparison,
  107.      respectively.  You should modify CODE, OP0, and OP1 as required.
  108.      GNU CC will not assume that the comparison resulting from this
  109.      macro is valid but will see if the resulting insn matches a
  110.      pattern in the `md' file.
  111.      You need not define this macro if it would never change the
  112.      comparison code or operands.
  113. `REVERSIBLE_CC_MODE (MODE)'
  114.      A C expression whose value is one if it is always safe to reverse a
  115.      comparison whose mode is MODE.  If `SELECT_CC_MODE' can ever
  116.      return MODE for a floating-point inequality comparison, then
  117.      `REVERSIBLE_CC_MODE (MODE)' must be zero.
  118.      You need not define this macro if it would always returns zero or
  119.      if the floating-point format is anything other than
  120.      `IEEE_FLOAT_FORMAT'.  For example, here is the definition used on
  121.      the Sparc, where floating-point inequality comparisons are always
  122.      given `CCFPEmode':
  123.           #define REVERSIBLE_CC_MODE(MODE)  ((MODE) != CCFPEmode)
  124. File: gcc.info,  Node: Costs,  Next: Sections,  Prev: Condition Code,  Up: Target Macros
  125. Describing Relative Costs of Operations
  126. =======================================
  127.    These macros let you describe the relative speed of various
  128. operations on the target machine.
  129. `CONST_COSTS (X, CODE, OUTER_CODE)'
  130.      A part of a C `switch' statement that describes the relative costs
  131.      of constant RTL expressions.  It must contain `case' labels for
  132.      expression codes `const_int', `const', `symbol_ref', `label_ref'
  133.      and `const_double'.  Each case must ultimately reach a `return'
  134.      statement to return the relative cost of the use of that kind of
  135.      constant value in an expression.  The cost may depend on the
  136.      precise value of the constant, which is available for examination
  137.      in X, and the rtx code of the expression in which it is contained,
  138.      found in OUTER_CODE.
  139.      CODE is the expression code--redundant, since it can be obtained
  140.      with `GET_CODE (X)'.
  141. `RTX_COSTS (X, CODE, OUTER_CODE)'
  142.      Like `CONST_COSTS' but applies to nonconstant RTL expressions.
  143.      This can be used, for example, to indicate how costly a multiply
  144.      instruction is.  In writing this macro, you can use the construct
  145.      `COSTS_N_INSNS (N)' to specify a cost equal to N fast
  146.      instructions.  OUTER_CODE is the code of the expression in which X
  147.      is contained.
  148.      This macro is optional; do not define it if the default cost
  149.      assumptions are adequate for the target machine.
  150. `ADDRESS_COST (ADDRESS)'
  151.      An expression giving the cost of an addressing mode that contains
  152.      ADDRESS.  If not defined, the cost is computed from the ADDRESS
  153.      expression and the `CONST_COSTS' values.
  154.      For most CISC machines, the default cost is a good approximation
  155.      of the true cost of the addressing mode.  However, on RISC
  156.      machines, all instructions normally have the same length and
  157.      execution time.  Hence all addresses will have equal costs.
  158.      In cases where more than one form of an address is known, the form
  159.      with the lowest cost will be used.  If multiple forms have the
  160.      same, lowest, cost, the one that is the most complex will be used.
  161.      For example, suppose an address that is equal to the sum of a
  162.      register and a constant is used twice in the same basic block.
  163.      When this macro is not defined, the address will be computed in a
  164.      register and memory references will be indirect through that
  165.      register.  On machines where the cost of the addressing mode
  166.      containing the sum is no higher than that of a simple indirect
  167.      reference, this will produce an additional instruction and
  168.      possibly require an additional register.  Proper specification of
  169.      this macro eliminates this overhead for such machines.
  170.      Similar use of this macro is made in strength reduction of loops.
  171.      ADDRESS need not be valid as an address.  In such a case, the cost
  172.      is not relevant and can be any value; invalid addresses need not be
  173.      assigned a different cost.
  174.      On machines where an address involving more than one register is as
  175.      cheap as an address computation involving only one register,
  176.      defining `ADDRESS_COST' to reflect this can cause two registers to
  177.      be live over a region of code where only one would have been if
  178.      `ADDRESS_COST' were not defined in that manner.  This effect should
  179.      be considered in the definition of this macro.  Equivalent costs
  180.      should probably only be given to addresses with different numbers
  181.      of registers on machines with lots of registers.
  182.      This macro will normally either not be defined or be defined as a
  183.      constant.
  184. `REGISTER_MOVE_COST (FROM, TO)'
  185.      A C expression for the cost of moving data from a register in class
  186.      FROM to one in class TO.  The classes are expressed using the
  187.      enumeration values such as `GENERAL_REGS'.  A value of 4 is the
  188.      default; other values are interpreted relative to that.
  189.      It is not required that the cost always equal 2 when FROM is the
  190.      same as TO; on some machines it is expensive to move between
  191.      registers if they are not general registers.
  192.      If reload sees an insn consisting of a single `set' between two
  193.      hard registers, and if `REGISTER_MOVE_COST' applied to their
  194.      classes returns a value of 2, reload does not check to ensure that
  195.      the constraints of the insn are met.  Setting a cost of other than
  196.      2 will allow reload to verify that the constraints are met.  You
  197.      should do this if the `movM' pattern's constraints do not allow
  198.      such copying.
  199. `MEMORY_MOVE_COST (M)'
  200.      A C expression for the cost of moving data of mode M between a
  201.      register and memory.  A value of 2 is the default; this cost is
  202.      relative to those in `REGISTER_MOVE_COST'.
  203.      If moving between registers and memory is more expensive than
  204.      between two registers, you should define this macro to express the
  205.      relative cost.
  206. `BRANCH_COST'
  207.      A C expression for the cost of a branch instruction.  A value of 1
  208.      is the default; other values are interpreted relative to that.
  209.    Here are additional macros which do not specify precise relative
  210. costs, but only that certain actions are more expensive than GNU CC
  211. would ordinarily expect.
  212. `SLOW_BYTE_ACCESS'
  213.      Define this macro as a C expression which is nonzero if accessing
  214.      less than a word of memory (i.e. a `char' or a `short') is no
  215.      faster than accessing a word of memory, i.e., if such access
  216.      require more than one instruction or if there is no difference in
  217.      cost between byte and (aligned) word loads.
  218.      When this macro is not defined, the compiler will access a field by
  219.      finding the smallest containing object; when it is defined, a
  220.      fullword load will be used if alignment permits.  Unless bytes
  221.      accesses are faster than word accesses, using word accesses is
  222.      preferable since it may eliminate subsequent memory access if
  223.      subsequent accesses occur to other fields in the same word of the
  224.      structure, but to different bytes.
  225. `SLOW_ZERO_EXTEND'
  226.      Define this macro if zero-extension (of a `char' or `short' to an
  227.      `int') can be done faster if the destination is a register that is
  228.      known to be zero.
  229.      If you define this macro, you must have instruction patterns that
  230.      recognize RTL structures like this:
  231.           (set (strict_low_part (subreg:QI (reg:SI ...) 0)) ...)
  232.      and likewise for `HImode'.
  233. `SLOW_UNALIGNED_ACCESS'
  234.      Define this macro to be the value 1 if unaligned accesses have a
  235.      cost many times greater than aligned accesses, for example if they
  236.      are emulated in a trap handler.
  237.      When this macro is non-zero, the compiler will act as if
  238.      `STRICT_ALIGNMENT' were non-zero when generating code for block
  239.      moves.  This can cause significantly more instructions to be
  240.      produced.  Therefore, do not set this macro non-zero if unaligned
  241.      accesses only add a cycle or two to the time for a memory access.
  242.      If the value of this macro is always zero, it need not be defined.
  243. `DONT_REDUCE_ADDR'
  244.      Define this macro to inhibit strength reduction of memory
  245.      addresses.  (On some machines, such strength reduction seems to do
  246.      harm rather than good.)
  247. `MOVE_RATIO'
  248.      The number of scalar move insns which should be generated instead
  249.      of a string move insn or a library call.  Increasing the value
  250.      will always make code faster, but eventually incurs high cost in
  251.      increased code size.
  252.      If you don't define this, a reasonable default is used.
  253. `NO_FUNCTION_CSE'
  254.      Define this macro if it is as good or better to call a constant
  255.      function address than to call an address kept in a register.
  256. `NO_RECURSIVE_FUNCTION_CSE'
  257.      Define this macro if it is as good or better for a function to call
  258.      itself with an explicit address than to call an address kept in a
  259.      register.
  260. `ADJUST_COST (INSN, LINK, DEP_INSN, COST)'
  261.      A C statement (sans semicolon) to update the integer variable COST
  262.      based on the relationship between INSN that is dependent on
  263.      DEP_INSN through the dependence LINK.  The default is to make no
  264.      adjustment to COST.  This can be used for example to specify to
  265.      the scheduler that an output- or anti-dependence does not incur
  266.      the same cost as a data-dependence.
  267. File: gcc.info,  Node: Sections,  Next: PIC,  Prev: Costs,  Up: Target Macros
  268. Dividing the Output into Sections (Texts, Data, ...)
  269. ====================================================
  270.    An object file is divided into sections containing different types of
  271. data.  In the most common case, there are three sections: the "text
  272. section", which holds instructions and read-only data; the "data
  273. section", which holds initialized writable data; and the "bss section",
  274. which holds uninitialized data.  Some systems have other kinds of
  275. sections.
  276.    The compiler must tell the assembler when to switch sections.  These
  277. macros control what commands to output to tell the assembler this.  You
  278. can also define additional sections.
  279. `TEXT_SECTION_ASM_OP'
  280.      A C expression whose value is a string containing the assembler
  281.      operation that should precede instructions and read-only data.
  282.      Normally `".text"' is right.
  283. `DATA_SECTION_ASM_OP'
  284.      A C expression whose value is a string containing the assembler
  285.      operation to identify the following data as writable initialized
  286.      data.  Normally `".data"' is right.
  287. `SHARED_SECTION_ASM_OP'
  288.      if defined, a C expression whose value is a string containing the
  289.      assembler operation to identify the following data as shared data.
  290.      If not defined, `DATA_SECTION_ASM_OP' will be used.
  291. `INIT_SECTION_ASM_OP'
  292.      if defined, a C expression whose value is a string containing the
  293.      assembler operation to identify the following data as
  294.      initialization code.  If not defined, GNU CC will assume such a
  295.      section does not exist.
  296. `EXTRA_SECTIONS'
  297.      A list of names for sections other than the standard two, which are
  298.      `in_text' and `in_data'.  You need not define this macro on a
  299.      system with no other sections (that GCC needs to use).
  300. `EXTRA_SECTION_FUNCTIONS'
  301.      One or more functions to be defined in `varasm.c'.  These
  302.      functions should do jobs analogous to those of `text_section' and
  303.      `data_section', for your additional sections.  Do not define this
  304.      macro if you do not define `EXTRA_SECTIONS'.
  305. `READONLY_DATA_SECTION'
  306.      On most machines, read-only variables, constants, and jump tables
  307.      are placed in the text section.  If this is not the case on your
  308.      machine, this macro should be defined to be the name of a function
  309.      (either `data_section' or a function defined in `EXTRA_SECTIONS')
  310.      that switches to the section to be used for read-only items.
  311.      If these items should be placed in the text section, this macro
  312.      should not be defined.
  313. `SELECT_SECTION (EXP, RELOC)'
  314.      A C statement or statements to switch to the appropriate section
  315.      for output of EXP.  You can assume that EXP is either a `VAR_DECL'
  316.      node or a constant of some sort.  RELOC indicates whether the
  317.      initial value of EXP requires link-time relocations.  Select the
  318.      section by calling `text_section' or one of the alternatives for
  319.      other sections.
  320.      Do not define this macro if you put all read-only variables and
  321.      constants in the read-only data section (usually the text section).
  322. `SELECT_RTX_SECTION (MODE, RTX)'
  323.      A C statement or statements to switch to the appropriate section
  324.      for output of RTX in mode MODE.  You can assume that RTX is some
  325.      kind of constant in RTL.  The argument MODE is redundant except in
  326.      the case of a `const_int' rtx.  Select the section by calling
  327.      `text_section' or one of the alternatives for other sections.
  328.      Do not define this macro if you put all constants in the read-only
  329.      data section.
  330. `JUMP_TABLES_IN_TEXT_SECTION'
  331.      Define this macro if jump tables (for `tablejump' insns) should be
  332.      output in the text section, along with the assembler instructions.
  333.      Otherwise, the readonly data section is used.
  334.      This macro is irrelevant if there is no separate readonly data
  335.      section.
  336. `ENCODE_SECTION_INFO (DECL)'
  337.      Define this macro if references to a symbol must be treated
  338.      differently depending on something about the variable or function
  339.      named by the symbol (such as what section it is in).
  340.      The macro definition, if any, is executed immediately after the
  341.      rtl for DECL has been created and stored in `DECL_RTL (DECL)'.
  342.      The value of the rtl will be a `mem' whose address is a
  343.      `symbol_ref'.
  344.      The usual thing for this macro to do is to record a flag in the
  345.      `symbol_ref' (such as `SYMBOL_REF_FLAG') or to store a modified
  346.      name string in the `symbol_ref' (if one bit is not enough
  347.      information).
  348. `STRIP_NAME_ENCODING (VAR, SYM_NAME)'
  349.      Decode SYM_NAME and store the real name part in VAR, sans the
  350.      characters that encode section info.  Define this macro if
  351.      `ENCODE_SECTION_INFO' alters the symbol's name string.
  352. File: gcc.info,  Node: PIC,  Next: Assembler Format,  Prev: Sections,  Up: Target Macros
  353. Position Independent Code
  354. =========================
  355.    This section describes macros that help implement generation of
  356. position independent code.  Simply defining these macros is not enough
  357. to generate valid PIC; you must also add support to the macros
  358. `GO_IF_LEGITIMATE_ADDRESS' and `PRINT_OPERAND_ADDRESS', as well as
  359. `LEGITIMIZE_ADDRESS'.  You must modify the definition of `movsi' to do
  360. something appropriate when the source operand contains a symbolic
  361. address.  You may also need to alter the handling of switch statements
  362. so that they use relative addresses.
  363. `PIC_OFFSET_TABLE_REGNUM'
  364.      The register number of the register used to address a table of
  365.      static data addresses in memory.  In some cases this register is
  366.      defined by a processor's "application binary interface" (ABI).
  367.      When this macro is defined, RTL is generated for this register
  368.      once, as with the stack pointer and frame pointer registers.  If
  369.      this macro is not defined, it is up to the machine-dependent files
  370.      to allocate such a register (if necessary).
  371.      findex PIC_OFFSET_TABLE_REG_CALL_CLOBBERED
  372. `PIC_OFFSET_TABLE_REG_CALL_CLOBBERED'
  373.      Define this macro if the register defined by
  374.      `PIC_OFFSET_TABLE_REGNUM' is clobbered by calls.  Do not define
  375.      this macro if `PPIC_OFFSET_TABLE_REGNUM' is not defined.
  376. `FINALIZE_PIC'
  377.      By generating position-independent code, when two different
  378.      programs (A and B) share a common library (libC.a), the text of
  379.      the library can be shared whether or not the library is linked at
  380.      the same address for both programs.  In some of these
  381.      environments, position-independent code requires not only the use
  382.      of different addressing modes, but also special code to enable the
  383.      use of these addressing modes.
  384.      The `FINALIZE_PIC' macro serves as a hook to emit these special
  385.      codes once the function is being compiled into assembly code, but
  386.      not before.  (It is not done before, because in the case of
  387.      compiling an inline function, it would lead to multiple PIC
  388.      prologues being included in functions which used inline functions
  389.      and were compiled to assembly language.)
  390. `LEGITIMATE_PIC_OPERAND_P (X)'
  391.      A C expression that is nonzero if X is a legitimate immediate
  392.      operand on the target machine when generating position independent
  393.      code.  You can assume that X satisfies `CONSTANT_P', so you need
  394.      not check this.  You can also assume FLAG_PIC is true, so you need
  395.      not check it either.  You need not define this macro if all
  396.      constants (including `SYMBOL_REF') can be immediate operands when
  397.      generating position independent code.
  398. File: gcc.info,  Node: Assembler Format,  Next: Debugging Info,  Prev: PIC,  Up: Target Macros
  399. Defining the Output Assembler Language
  400. ======================================
  401.    This section describes macros whose principal purpose is to describe
  402. how to write instructions in assembler language-rather than what the
  403. instructions do.
  404. * Menu:
  405. * File Framework::       Structural information for the assembler file.
  406. * Data Output::          Output of constants (numbers, strings, addresses).
  407. * Uninitialized Data::   Output of uninitialized variables.
  408. * Label Output::         Output and generation of labels.
  409. * Initialization::       General principles of initialization
  410.                and termination routines.
  411. * Macros for Initialization::
  412.              Specific macros that control the handling of
  413.                initialization and termination routines.
  414. * Instruction Output::   Output of actual instructions.
  415. * Dispatch Tables::      Output of jump tables.
  416. * Alignment Output::     Pseudo ops for alignment and skipping data.
  417. File: gcc.info,  Node: File Framework,  Next: Data Output,  Up: Assembler Format
  418. The Overall Framework of an Assembler File
  419. ------------------------------------------
  420. `ASM_FILE_START (STREAM)'
  421.      A C expression which outputs to the stdio stream STREAM some
  422.      appropriate text to go at the start of an assembler file.
  423.      Normally this macro is defined to output a line containing
  424.      `#NO_APP', which is a comment that has no effect on most
  425.      assemblers but tells the GNU assembler that it can save time by not
  426.      checking for certain assembler constructs.
  427.      On systems that use SDB, it is necessary to output certain
  428.      commands; see `attasm.h'.
  429. `ASM_FILE_END (STREAM)'
  430.      A C expression which outputs to the stdio stream STREAM some
  431.      appropriate text to go at the end of an assembler file.
  432.      If this macro is not defined, the default is to output nothing
  433.      special at the end of the file.  Most systems don't require any
  434.      definition.
  435.      On systems that use SDB, it is necessary to output certain
  436.      commands; see `attasm.h'.
  437. `ASM_IDENTIFY_GCC (FILE)'
  438.      A C statement to output assembler commands which will identify the
  439.      object file as having been compiled with GNU CC (or another GNU
  440.      compiler).
  441.      If you don't define this macro, the string `gcc_compiled.:' is
  442.      output.  This string is calculated to define a symbol which, on
  443.      BSD systems, will never be defined for any other reason.  GDB
  444.      checks for the presence of this symbol when reading the symbol
  445.      table of an executable.
  446.      On non-BSD systems, you must arrange communication with GDB in
  447.      some other fashion.  If GDB is not used on your system, you can
  448.      define this macro with an empty body.
  449. `ASM_COMMENT_START'
  450.      A C string constant describing how to begin a comment in the target
  451.      assembler language.  The compiler assumes that the comment will
  452.      end at the end of the line.
  453. `ASM_APP_ON'
  454.      A C string constant for text to be output before each `asm'
  455.      statement or group of consecutive ones.  Normally this is
  456.      `"#APP"', which is a comment that has no effect on most assemblers
  457.      but tells the GNU assembler that it must check the lines that
  458.      follow for all valid assembler constructs.
  459. `ASM_APP_OFF'
  460.      A C string constant for text to be output after each `asm'
  461.      statement or group of consecutive ones.  Normally this is
  462.      `"#NO_APP"', which tells the GNU assembler to resume making the
  463.      time-saving assumptions that are valid for ordinary compiler
  464.      output.
  465. `ASM_OUTPUT_SOURCE_FILENAME (STREAM, NAME)'
  466.      A C statement to output COFF information or DWARF debugging
  467.      information which indicates that filename NAME is the current
  468.      source file to the stdio stream STREAM.
  469.      This macro need not be defined if the standard form of output for
  470.      the file format in use is appropriate.
  471. `ASM_OUTPUT_SOURCE_LINE (STREAM, LINE)'
  472.      A C statement to output DBX or SDB debugging information before
  473.      code for line number LINE of the current source file to the stdio
  474.      stream STREAM.
  475.      This macro need not be defined if the standard form of debugging
  476.      information for the debugger in use is appropriate.
  477. `ASM_OUTPUT_IDENT (STREAM, STRING)'
  478.      A C statement to output something to the assembler file to handle a
  479.      `#ident' directive containing the text STRING.  If this macro is
  480.      not defined, nothing is output for a `#ident' directive.
  481. `ASM_OUTPUT_SECTION_NAME (STREAM, STRING)'
  482.      A C statement to output something to the assembler file to switch
  483.      to the section contained in STRING.  Some target formats do not
  484.      support arbitrary sections.  Do not define this macro in such
  485.      cases.
  486.      At present this macro is only used to support section attributes.
  487.      When this macro is undefined, section attributes are disabled.
  488. `OBJC_PROLOGUE'
  489.      A C statement to output any assembler statements which are
  490.      required to precede any Objective C object definitions or message
  491.      sending.  The statement is executed only when compiling an
  492.      Objective C program.
  493. File: gcc.info,  Node: Data Output,  Next: Uninitialized Data,  Prev: File Framework,  Up: Assembler Format
  494. Output of Data
  495. --------------
  496. `ASM_OUTPUT_LONG_DOUBLE (STREAM, VALUE)'
  497. `ASM_OUTPUT_DOUBLE (STREAM, VALUE)'
  498. `ASM_OUTPUT_FLOAT (STREAM, VALUE)'
  499. `ASM_OUTPUT_THREE_QUARTER_FLOAT (STREAM, VALUE)'
  500. `ASM_OUTPUT_SHORT_FLOAT (STREAM, VALUE)'
  501. `ASM_OUTPUT_BYTE_FLOAT (STREAM, VALUE)'
  502.      A C statement to output to the stdio stream STREAM an assembler
  503.      instruction to assemble a floating-point constant of `TFmode',
  504.      `DFmode', `SFmode', `TQFmode', `HFmode', or `QFmode',
  505.      respectively, whose value is VALUE.  VALUE will be a C expression
  506.      of type `REAL_VALUE_TYPE'.  Macros such as
  507.      `REAL_VALUE_TO_TARGET_DOUBLE' are useful for writing these
  508.      definitions.
  509. `ASM_OUTPUT_QUADRUPLE_INT (STREAM, EXP)'
  510. `ASM_OUTPUT_DOUBLE_INT (STREAM, EXP)'
  511. `ASM_OUTPUT_INT (STREAM, EXP)'
  512. `ASM_OUTPUT_SHORT (STREAM, EXP)'
  513. `ASM_OUTPUT_CHAR (STREAM, EXP)'
  514.      A C statement to output to the stdio stream STREAM an assembler
  515.      instruction to assemble an integer of 16, 8, 4, 2 or 1 bytes,
  516.      respectively, whose value is VALUE.  The argument EXP will be an
  517.      RTL expression which represents a constant value.  Use
  518.      `output_addr_const (STREAM, EXP)' to output this value as an
  519.      assembler expression.
  520.      For sizes larger than `UNITS_PER_WORD', if the action of a macro
  521.      would be identical to repeatedly calling the macro corresponding to
  522.      a size of `UNITS_PER_WORD', once for each word, you need not define
  523.      the macro.
  524. `ASM_OUTPUT_BYTE (STREAM, VALUE)'
  525.      A C statement to output to the stdio stream STREAM an assembler
  526.      instruction to assemble a single byte containing the number VALUE.
  527. `ASM_BYTE_OP'
  528.      A C string constant giving the pseudo-op to use for a sequence of
  529.      single-byte constants.  If this macro is not defined, the default
  530.      is `"byte"'.
  531. `ASM_OUTPUT_ASCII (STREAM, PTR, LEN)'
  532.      A C statement to output to the stdio stream STREAM an assembler
  533.      instruction to assemble a string constant containing the LEN bytes
  534.      at PTR.  PTR will be a C expression of type `char *' and LEN a C
  535.      expression of type `int'.
  536.      If the assembler has a `.ascii' pseudo-op as found in the Berkeley
  537.      Unix assembler, do not define the macro `ASM_OUTPUT_ASCII'.
  538. `ASM_OUTPUT_POOL_PROLOGUE (FILE FUNNAME FUNDECL SIZE)'
  539.      A C statement to output assembler commands to define the start of
  540.      the constant pool for a function.  FUNNAME is a string giving the
  541.      name of the function.  Should the return type of the function be
  542.      required, it can be obtained via FUNDECL.  SIZE is the size, in
  543.      bytes, of the constant pool that will be written immediately after
  544.      this call.
  545.      If no constant-pool prefix is required, the usual case, this macro
  546.      need not be defined.
  547. `ASM_OUTPUT_SPECIAL_POOL_ENTRY (FILE, X, MODE, ALIGN, LABELNO, JUMPTO)'
  548.      A C statement (with or without semicolon) to output a constant in
  549.      the constant pool, if it needs special treatment.  (This macro
  550.      need not do anything for RTL expressions that can be output
  551.      normally.)
  552.      The argument FILE is the standard I/O stream to output the
  553.      assembler code on.  X is the RTL expression for the constant to
  554.      output, and MODE is the machine mode (in case X is a `const_int').
  555.      ALIGN is the required alignment for the value X; you should
  556.      output an assembler directive to force this much alignment.
  557.      The argument LABELNO is a number to use in an internal label for
  558.      the address of this pool entry.  The definition of this macro is
  559.      responsible for outputting the label definition at the proper
  560.      place.  Here is how to do this:
  561.           ASM_OUTPUT_INTERNAL_LABEL (FILE, "LC", LABELNO);
  562.      When you output a pool entry specially, you should end with a
  563.      `goto' to the label JUMPTO.  This will prevent the same pool entry
  564.      from being output a second time in the usual manner.
  565.      You need not define this macro if it would do nothing.
  566. `IS_ASM_LOGICAL_LINE_SEPARATOR (C)'
  567.      Define this macro as a C expression which is nonzero if C is used
  568.      as a logical line separator by the assembler.
  569.      If you do not define this macro, the default is that only the
  570.      character `;' is treated as a logical line separator.
  571. `ASM_OPEN_PAREN'
  572. `ASM_CLOSE_PAREN'
  573.      These macros are defined as C string constant, describing the
  574.      syntax in the assembler for grouping arithmetic expressions.  The
  575.      following definitions are correct for most assemblers:
  576.           #define ASM_OPEN_PAREN "("
  577.           #define ASM_CLOSE_PAREN ")"
  578.    These macros are provided by `real.h' for writing the definitions of
  579. `ASM_OUTPUT_DOUBLE' and the like:
  580. `REAL_VALUE_TO_TARGET_SINGLE (X, L)'
  581. `REAL_VALUE_TO_TARGET_DOUBLE (X, L)'
  582. `REAL_VALUE_TO_TARGET_LONG_DOUBLE (X, L)'
  583.      These translate X, of type `REAL_VALUE_TYPE', to the target's
  584.      floating point representation, and store its bit pattern in the
  585.      array of `long int' whose address is L.  The number of elements in
  586.      the output array is determined by the size of the desired target
  587.      floating point data type: 32 bits of it go in each `long int' array
  588.      element.  Each array element holds 32 bits of the result, even if
  589.      `long int' is wider than 32 bits on the host machine.
  590.      The array element values are designed so that you can print them
  591.      out using `fprintf' in the order they should appear in the target
  592.      machine's memory.
  593. `REAL_VALUE_TO_DECIMAL (X, FORMAT, STRING)'
  594.      This macro converts X, of type `REAL_VALUE_TYPE', to a decimal
  595.      number and stores it as a string into STRING.  You must pass, as
  596.      STRING, the address of a long enough block of space to hold the
  597.      result.
  598.      The argument FORMAT is a `printf'-specification that serves as a
  599.      suggestion for how to format the output string.
  600. File: gcc.info,  Node: Uninitialized Data,  Next: Label Output,  Prev: Data Output,  Up: Assembler Format
  601. Output of Uninitialized Variables
  602. ---------------------------------
  603.    Each of the macros in this section is used to do the whole job of
  604. outputting a single uninitialized variable.
  605. `ASM_OUTPUT_COMMON (STREAM, NAME, SIZE, ROUNDED)'
  606.      A C statement (sans semicolon) to output to the stdio stream
  607.      STREAM the assembler definition of a common-label named NAME whose
  608.      size is SIZE bytes.  The variable ROUNDED is the size rounded up
  609.      to whatever alignment the caller wants.
  610.      Use the expression `assemble_name (STREAM, NAME)' to output the
  611.      name itself; before and after that, output the additional
  612.      assembler syntax for defining the name, and a newline.
  613.      This macro controls how the assembler definitions of uninitialized
  614.      global variables are output.
  615. `ASM_OUTPUT_ALIGNED_COMMON (STREAM, NAME, SIZE, ALIGNMENT)'
  616.      Like `ASM_OUTPUT_COMMON' except takes the required alignment as a
  617.      separate, explicit argument.  If you define this macro, it is used
  618.      in place of `ASM_OUTPUT_COMMON', and gives you more flexibility in
  619.      handling the required alignment of the variable.  The alignment is
  620.      specified as the number of bits.
  621. `ASM_OUTPUT_SHARED_COMMON (STREAM, NAME, SIZE, ROUNDED)'
  622.      If defined, it is similar to `ASM_OUTPUT_COMMON', except that it
  623.      is used when NAME is shared.  If not defined, `ASM_OUTPUT_COMMON'
  624.      will be used.
  625. `ASM_OUTPUT_LOCAL (STREAM, NAME, SIZE, ROUNDED)'
  626.      A C statement (sans semicolon) to output to the stdio stream
  627.      STREAM the assembler definition of a local-common-label named NAME
  628.      whose size is SIZE bytes.  The variable ROUNDED is the size
  629.      rounded up to whatever alignment the caller wants.
  630.      Use the expression `assemble_name (STREAM, NAME)' to output the
  631.      name itself; before and after that, output the additional
  632.      assembler syntax for defining the name, and a newline.
  633.      This macro controls how the assembler definitions of uninitialized
  634.      static variables are output.
  635. `ASM_OUTPUT_ALIGNED_LOCAL (STREAM, NAME, SIZE, ALIGNMENT)'
  636.      Like `ASM_OUTPUT_LOCAL' except takes the required alignment as a
  637.      separate, explicit argument.  If you define this macro, it is used
  638.      in place of `ASM_OUTPUT_LOCAL', and gives you more flexibility in
  639.      handling the required alignment of the variable.  The alignment is
  640.      specified as the number of bits.
  641. `ASM_OUTPUT_SHARED_LOCAL (STREAM, NAME, SIZE, ROUNDED)'
  642.      If defined, it is similar to `ASM_OUTPUT_LOCAL', except that it is
  643.      used when NAME is shared.  If not defined, `ASM_OUTPUT_LOCAL' will
  644.      be used.
  645. File: gcc.info,  Node: Label Output,  Next: Initialization,  Prev: Uninitialized Data,  Up: Assembler Format
  646. Output and Generation of Labels
  647. -------------------------------
  648. `ASM_OUTPUT_LABEL (STREAM, NAME)'
  649.      A C statement (sans semicolon) to output to the stdio stream
  650.      STREAM the assembler definition of a label named NAME.  Use the
  651.      expression `assemble_name (STREAM, NAME)' to output the name
  652.      itself; before and after that, output the additional assembler
  653.      syntax for defining the name, and a newline.
  654. `ASM_DECLARE_FUNCTION_NAME (STREAM, NAME, DECL)'
  655.      A C statement (sans semicolon) to output to the stdio stream
  656.      STREAM any text necessary for declaring the name NAME of a
  657.      function which is being defined.  This macro is responsible for
  658.      outputting the label definition (perhaps using
  659.      `ASM_OUTPUT_LABEL').  The argument DECL is the `FUNCTION_DECL'
  660.      tree node representing the function.
  661.      If this macro is not defined, then the function name is defined in
  662.      the usual manner as a label (by means of `ASM_OUTPUT_LABEL').
  663. `ASM_DECLARE_FUNCTION_SIZE (STREAM, NAME, DECL)'
  664.      A C statement (sans semicolon) to output to the stdio stream
  665.      STREAM any text necessary for declaring the size of a function
  666.      which is being defined.  The argument NAME is the name of the
  667.      function.  The argument DECL is the `FUNCTION_DECL' tree node
  668.      representing the function.
  669.      If this macro is not defined, then the function size is not
  670.      defined.
  671. `ASM_DECLARE_OBJECT_NAME (STREAM, NAME, DECL)'
  672.      A C statement (sans semicolon) to output to the stdio stream
  673.      STREAM any text necessary for declaring the name NAME of an
  674.      initialized variable which is being defined.  This macro must
  675.      output the label definition (perhaps using `ASM_OUTPUT_LABEL').
  676.      The argument DECL is the `VAR_DECL' tree node representing the
  677.      variable.
  678.      If this macro is not defined, then the variable name is defined in
  679.      the usual manner as a label (by means of `ASM_OUTPUT_LABEL').
  680. `ASM_FINISH_DECLARE_OBJECT (STREAM, DECL, TOPLEVEL, ATEND)'
  681.      A C statement (sans semicolon) to finish up declaring a variable
  682.      name once the compiler has processed its initializer fully and
  683.      thus has had a chance to determine the size of an array when
  684.      controlled by an initializer.  This is used on systems where it's
  685.      necessary to declare something about the size of the object.
  686.      If you don't define this macro, that is equivalent to defining it
  687.      to do nothing.
  688. `ASM_GLOBALIZE_LABEL (STREAM, NAME)'
  689.      A C statement (sans semicolon) to output to the stdio stream
  690.      STREAM some commands that will make the label NAME global; that
  691.      is, available for reference from other files.  Use the expression
  692.      `assemble_name (STREAM, NAME)' to output the name itself; before
  693.      and after that, output the additional assembler syntax for making
  694.      that name global, and a newline.
  695. `ASM_OUTPUT_EXTERNAL (STREAM, DECL, NAME)'
  696.      A C statement (sans semicolon) to output to the stdio stream
  697.      STREAM any text necessary for declaring the name of an external
  698.      symbol named NAME which is referenced in this compilation but not
  699.      defined.  The value of DECL is the tree node for the declaration.
  700.      This macro need not be defined if it does not need to output
  701.      anything.  The GNU assembler and most Unix assemblers don't
  702.      require anything.
  703. `ASM_OUTPUT_EXTERNAL_LIBCALL (STREAM, SYMREF)'
  704.      A C statement (sans semicolon) to output on STREAM an assembler
  705.      pseudo-op to declare a library function name external.  The name
  706.      of the library function is given by SYMREF, which has type `rtx'
  707.      and is a `symbol_ref'.
  708.      This macro need not be defined if it does not need to output
  709.      anything.  The GNU assembler and most Unix assemblers don't
  710.      require anything.
  711. `ASM_OUTPUT_LABELREF (STREAM, NAME)'
  712.      A C statement (sans semicolon) to output to the stdio stream
  713.      STREAM a reference in assembler syntax to a label named NAME.
  714.      This should add `_' to the front of the name, if that is customary
  715.      on your operating system, as it is in most Berkeley Unix systems.
  716.      This macro is used in `assemble_name'.
  717. `ASM_OUTPUT_INTERNAL_LABEL (STREAM, PREFIX, NUM)'
  718.      A C statement to output to the stdio stream STREAM a label whose
  719.      name is made from the string PREFIX and the number NUM.
  720.      It is absolutely essential that these labels be distinct from the
  721.      labels used for user-level functions and variables.  Otherwise,
  722.      certain programs will have name conflicts with internal labels.
  723.      It is desirable to exclude internal labels from the symbol table
  724.      of the object file.  Most assemblers have a naming convention for
  725.      labels that should be excluded; on many systems, the letter `L' at
  726.      the beginning of a label has this effect.  You should find out what
  727.      convention your system uses, and follow it.
  728.      The usual definition of this macro is as follows:
  729.           fprintf (STREAM, "L%s%d:\n", PREFIX, NUM)
  730. `ASM_GENERATE_INTERNAL_LABEL (STRING, PREFIX, NUM)'
  731.      A C statement to store into the string STRING a label whose name
  732.      is made from the string PREFIX and the number NUM.
  733.      This string, when output subsequently by `assemble_name', should
  734.      produce the output that `ASM_OUTPUT_INTERNAL_LABEL' would produce
  735.      with the same PREFIX and NUM.
  736.      If the string begins with `*', then `assemble_name' will output
  737.      the rest of the string unchanged.  It is often convenient for
  738.      `ASM_GENERATE_INTERNAL_LABEL' to use `*' in this way.  If the
  739.      string doesn't start with `*', then `ASM_OUTPUT_LABELREF' gets to
  740.      output the string, and may change it.  (Of course,
  741.      `ASM_OUTPUT_LABELREF' is also part of your machine description, so
  742.      you should know what it does on your machine.)
  743. `ASM_FORMAT_PRIVATE_NAME (OUTVAR, NAME, NUMBER)'
  744.      A C expression to assign to OUTVAR (which is a variable of type
  745.      `char *') a newly allocated string made from the string NAME and
  746.      the number NUMBER, with some suitable punctuation added.  Use
  747.      `alloca' to get space for the string.
  748.      The string will be used as an argument to `ASM_OUTPUT_LABELREF' to
  749.      produce an assembler label for an internal static variable whose
  750.      name is NAME.  Therefore, the string must be such as to result in
  751.      valid assembler code.  The argument NUMBER is different each time
  752.      this macro is executed; it prevents conflicts between
  753.      similarly-named internal static variables in different scopes.
  754.      Ideally this string should not be a valid C identifier, to prevent
  755.      any conflict with the user's own symbols.  Most assemblers allow
  756.      periods or percent signs in assembler symbols; putting at least
  757.      one of these between the name and the number will suffice.
  758. `ASM_OUTPUT_DEF (STREAM, NAME, VALUE)'
  759.      A C statement to output to the stdio stream STREAM assembler code
  760.      which defines (equates) the symbol NAME to have the value VALUE.
  761.      If SET_ASM_OP is defined, a default definition is provided which is
  762.      correct for most systems.
  763. `OBJC_GEN_METHOD_LABEL (BUF, IS_INST, CLASS_NAME, CAT_NAME, SEL_NAME)'
  764.      Define this macro to override the default assembler names used for
  765.      Objective C methods.
  766.      The default name is a unique method number followed by the name of
  767.      the class (e.g. `_1_Foo').  For methods in categories, the name of
  768.      the category is also included in the assembler name (e.g.
  769.      `_1_Foo_Bar').
  770.      These names are safe on most systems, but make debugging difficult
  771.      since the method's selector is not present in the name.
  772.      Therefore, particular systems define other ways of computing names.
  773.      BUF is an expression of type `char *' which gives you a buffer in
  774.      which to store the name; its length is as long as CLASS_NAME,
  775.      CAT_NAME and SEL_NAME put together, plus 50 characters extra.
  776.      The argument IS_INST specifies whether the method is an instance
  777.      method or a class method; CLASS_NAME is the name of the class;
  778.      CAT_NAME is the name of the category (or NULL if the method is not
  779.      in a category); and SEL_NAME is the name of the selector.
  780.      On systems where the assembler can handle quoted names, you can
  781.      use this macro to provide more human-readable names.
  782.